const express = require('express');

const router = express.Router();

const conn = require('../configs/db');

const svgCaptcha = require('svg-captcha');

const { randomCode,sendCode} = require('../util/sms_util')

let users = {}

/*
   json数据的批量导入mysql数据库
* */
const recommendArray = require('./../data/recommend').data;
router.get('/recommend/api',(req,res,next)=>{
    // 1.定义临时数据
    let temp_arr_all = [];
    // 2.遍历json数据
    for(let i=0;i<recommendArray.length;i++){
        // 2.1取出单个数据对象
        let oldItem = recommendArray[i];
        // 2.2取出数据表中对应的字段
        let temp_arr = [];
        temp_arr.push(oldItem.goods_id);
        temp_arr.push(oldItem.goods_name);
        temp_arr.push(oldItem.short_name);
        temp_arr.push(oldItem.thumb_url);
        temp_arr.push(oldItem.hd_thumb_url);
        temp_arr.push(oldItem.image_url);
        temp_arr.push(oldItem.price);
        temp_arr.push(oldItem.normal_price);
        temp_arr.push(oldItem.market_price);
        temp_arr.push(oldItem.sales_tip);
        temp_arr.push(oldItem.hd_url);
        // 2.3合并到大的数据
        temp_arr_all.push(temp_arr);
    }
    // 3.使用sql语句批量导入到数据库中
    let query = "INSERT INTO pdd_recommendlist(`goods_id`,`goods_name`,`short_name`, `thumb_url`, `hd_thumb_url`, `image_url`, `price`, `normal_price`, `market_price`, `sales_tip`, `hd_url`) VALUES ?";
    // 使用带?号的sql查询时，会将第二个参数[temp_arr_all]拼接到后面
    conn.query(query, [temp_arr_all],(error,result,fields)=>{
        if(error){
            console.log(error);
        }else {
            console.log('数据插入成功')
        }
    })
})

const homenavArray = require('./../data/homenav').data;
router.get('/homenav/api',(req,res,next)=>{
    let temp_all = [];
    for(let i=0;i<homenavArray.length;i++){
        let item = [];
        item.push(homenavArray[i].iconurl);
        item.push(homenavArray[i].icontitle);
        temp_all.push(item);
    }
    let sqlStr = "INSERT INTO pdd_homenav(iconurl,icontitle) VALUES ?";
    conn.query(sqlStr,[temp_all],(error,result,fields)=>{
        if(error){
            console.log(error);
        }else {
            console.log('数据插入成功');
        }
    })
})


/*
  获取首页轮播图
*/
router.get('/api/homecasual', (req, res)=>{
    // 方式一：使用jsonw文件的形式获取(mongoodb的前身)
    /*const data = require('./../data/homecasual');
    res.json(data);*/
    // 方式二：使用mysql的形式
    let query = 'SELECT * FROM pdd_homecasual';
    conn.query(query,(error,result,fields)=>{
        if(error){
            res.json({err_code: 0, message: '请求数据失败'});
        }else {
            res.json({success_code:200, message: result});
        }
    })
});
/*
  获取首页导航
 */
router.get('/api/homenav', (req, res)=>{
    // 方式一：使用json文件的形式（最开始的node练习用的就是方式，这也是mongodb的前身）
    /*const navJson = require('./../data/homenav');
    res.json({success_code: 200, message: navJson.data});*/
    // 方式二：使用mysql数据库的形式
    let query = 'SELECT * FROM pdd_homenav';
    conn.query(query,(error,result,fields)=>{
        if(error){
            res.json({err_code:0,message:'请求数据失败'});
        }else {
            res.json({success_code:200,message:result});
        }
    })
});
/*
  获取首页商品列表
 */
router.get('/api/homeshoplist', (req, res)=>{
    const data = require('./../data/shopList');
    res.json({success_code: 200, message: data});
});
/*
  获取推荐页数据
*/
router.get('/api/recommendshoplist', (req, res) => {
    // 方式一：后端使用json文件的格式存储数据
    /*const data = require('./../data/recommend');
    res.json({success_code: 200, message: data});*/
    // 方式二：后端使用mysql存储数据，且实现真分页
    let pageNo = req.query.pageNum || 1;
    let pageSize = req.query.pageSize || 20;
    let sqlStr = `SELECT * FROM pdd_recommendlist LIMIT ${(pageNo-1)*pageSize},${pageSize}`;
    conn.query(sqlStr,(error,result,fields)=>{
        if(error){
            res.json({err_code:0,message:'查询失败'});
        }else {
            // 模拟网络延时
            setTimeout(()=>{
                res.json({success_code:200,message:result});
            },500);
        }
    })
});
/*
  获取搜索分类列表
 */
router.get('/api/searchgoods', (req, res)=>{
    const data = require('./../data/search');
    res.json({success_code: 200, message: data});
});

/*
*  获取一次性图形验证码
* */
router.get('/api/captcha',(req,res)=>{
    // 生产随机验证码
    let captcha = svgCaptcha.create({
        color: true,
        noise: 2,
        size: 4,
        ignoreChars: '0o1i'
    });
    // 保存到服务器的session中,方便下次校验使用
    req.session.captcha = captcha.text.toLocaleLowerCase();
    // 返回客户端
    res.type('svg');
    res.status(200).send(captcha.data);
});

/*
*   后端生成手机验证码，通过短信供应商发送给用户手机
* */
router.get('/api/sendCode',(req,res)=>{
    // 从请求中获取手机号码
    let phoneNum = req.query.phoneNum;
    // 生成随机验证码
    let code = randomCode(6);
    // 使用第三方短信提供商提供的接口，发送验证码，但是都是收费的所以都是不成功的。为了后续开发，现在使用方式2
    /*sendCode('18912989092', code, function (success) {
       if(success){
           users[phoneNum] = code;
           res.json({success_code:200,message:'验证码已发送'})
       }else {
           res.json({success_code: 0,message:'验证码发送失败'})
       }
    })*/
    // 方式2
    setTimeout(()=>{// 模拟网络延时
        // 存储验证码，方便校验(正常情况下应该用session存储)
        users[phoneNum] = code;
        res.json({success_code:200,message:code});
    },3000);
    // 模拟失败时弹窗的效果
    //res.json({success_code:0,message:"验证码发送失败"});
});

/*
*   手机验证码登录
* */
router.post('/api/login_code',(req,res)=>{
    // 获取前台传来的数据
    const phone = req.body.phone;
    const code = req.body.code;
    // res.json({success_code:0,message:phone});   该段代码未注释导致了这个错误Cannot set headers after they are sent to the client
                                                // 本质就是一个请求对应一个响应，如果存在一对多就会出现以上报错
    // 两次校验之一：验证码校验
    if(users[phone] != code){
        res.json({success_code:0,message:'验证码不正确'});
        return;
    }
    // 验证码校验通过后，要清除该验证码，因为是一次性的
    delete users[phone];
    // 查询数据库是否存在该用户
    let sql = "SELECT * FROM pdd_user_info WHERE phone = " + phone + " LIMIT 1";
    conn.query(sql,(error,result,fields)=>{
        if(error){
            console.log(error);
            res.json({success_code:0,message:'服务器错误'});
            return;
        }
        if(result[0]){
            // 数据库查到的数据是rowDataStack格式的，后端要转成json格式的返回给前台
            result = JSON.parse(JSON.stringify(result));
            // 使用session存储一下查询到的用户id,当用户再次登录时可以快速登录
            req.session.userId = result[0].id;
            // 将用户信息有选择性的返回给前台
            //res.json({success_code:200,message:{id:result[0].id,user_name:result[0].user_name,phone:result[0].phone}});
            res.json({success_code:200,message:result[0]});
        }else {
            // 未查询到用户，创建用户
            let sql = 'INSERT INTO pdd_user_info(user_name, phone) VALUES (?,?);'
            conn.query(sql,[phone,phone],(error,result,fields)=>{
                if(error){
                   res.json({success_code:0,message:'用户不合法'});
                   return;
                }
                result = JSON.parse(JSON.stringify(result));
                req.session.userId = result.insertId;
                let sqlStr =  "SELECT * FROM pdd_user_info WHERE id = " + result.insertId + " LIMIT 1";
                conn.query(sqlStr,(error,result,fields)=>{
                    if(error){
                        res.json({success_code:0,message:'服务内部错误'});
                        return;
                    }
                    result = JSON.parse(JSON.stringify(result));
                    //res.json({success_code:200,message:{id:result[0].id,user_name:result[0].user_name,phone:result[0].phone}});
                    res.json({success_code:200,message:result[0]});
                })
            })
        }
    })
});

/*
*   账户密码登录
* */
router.post('/api/login',(req,res)=>{
    // 获取前台传来的参数
    let account = req.body.account;
    let pwd = req.body.password;    // 后期需要对密码进行双md5加密存储
    let code = req.body.code;
    /*
    * 这里通过一个问题引入一个node代码调试的一个方法。
    * 问题：输入的验证码明明正确，可以返回回去的是图形验证码不正确。
    * node代码调试方式一：大致判断出错代码区域（没错就是下面这块）
    *                     将除了该处代码的其他代码全部注释调，然后通过控制台的方式查看  用户传来的code  session存储的captcha  session来排除错误
    * 通过上述调试方式发现错误的原因在于：session对象中根本没有captcha。 不是同一个客户端发送的请求，是拿不到同一个session容器中的某个属性的
    * */
    /*console.log(code, req.session.captcha, req.session);*/
    if(req.session.captcha != code.toLocaleLowerCase()){
        res.json({success_code:0,message:'图形验证码不正确'});
        return;
    }
    delete req.session.captcha;
    // 根据用户名，密码查询用户是否存在
    let sql = "SELECT * FROM pdd_user_info WHERE user_name = '" + account + "' LIMIT 1";
    conn.query(sql,(error,result,fields)=>{
        if(error){
            console.log(error);
            res.json({success_code:0,message:'服务器错误'});
            return;
        }
        result = JSON.parse(JSON.stringify(result));
        if(result[0]){// 用户存在
            if(result[0].user_pwd == pwd){// 验证密码
                req.session.userId = result[0].id;
                res.json({success_code:200,message:{
                    id:result[0].id,
                    userName: result[0].user_name
                }})
            }else {
                res.json({success_code:0,message:'密码错误'})
            }
        }else {// 查询结果为空，无此用户   此时可以做处理有自动创建用户，跳转到注册页面
            /*res.json({success_code:0,message:'该用户尚未注册'});*/     // 后续实现

            // 不太合理的方式
            let sql = 'INSERT INTO pdd_user_info(user_name, user_pwd) VALUES (?,?);'
            conn.query(sql,[account,pwd],(error,result,fields)=>{
                if(error){
                    res.json({success_code:0,message:'用户不合法'});
                    return;
                }
                result = JSON.parse(JSON.stringify(result));
                req.session.userId = result.insertId;
                let sqlStr =  "SELECT * FROM pdd_user_info WHERE id = " + result.insertId + " LIMIT 1";
                conn.query(sqlStr,(error,result,fields)=>{
                    if(error){
                        res.json({success_code:0,message:'服务内部错误'});
                        return;
                    }
                    result = JSON.parse(JSON.stringify(result));
                    res.json({success_code:200,message:{id:result[0].id,user_name:result[0].user_name,phone:result[0].phone}});
                })
            })
        }
    })
});

/*
*   后台通过session实现一段时间内无需验证自动登录自动登录
* */
router.get('/api/login_auto',(req,res)=>{
    // 在用户登录一次后我们已经将id存储到了服务器的session中，在网页刚刚打开时直接验证存储在session中的数据是否失效
    if(!req.session.userId){// session失效时
        res.json({success_code:0,message:'登录失效,请重新登录'});
        delete req.session.userId;
        return;
    }
    // session未失效
    let uid = req.session.userId;
    let sql = "SELECT * FROM pdd_user_info WHERE id = " + uid + " LIMIT 1";
    conn.query(sql,(error,result,fields)=>{ // 回调参数中的fields是查询到结果的字段描述（以后不知道这个参数是什么意思，直接打印看一下不就得了！！！）
        if(error){
            console.log(error);
            res.json({success_code:0,message:'服务器出错'});
            return;
        }
        // 数据库查询的结果都是rowDataStack格式的数据，要先转化
        result = JSON.parse(JSON.stringify(result));
        //res.json({success_code:200,message:{id:result[0].id,user_name:result[0].user_name,phone:result[0].phone}})
        res.json({success_code:200,message:result[0]});
    })
});

/*
*   实现退出登录接口(后台需要的逻辑)
* */
router.get('/api/loginout',(req,res)=>{
    // 1.清除session中的用户id
    delete req.session.userId;
    // 2.给用户返回提示信息
    res.json({success_code:200,message:'退出登录成功'});
});

/*
*   修改用户信息
* */
router.post('/api/change_user_info',(req,res)=>{
    // 获取数据
    const id = req.body.user_id || '';
    const user_name = req.body.user_name || '';
    const user_sex = req.body.user_sex || '';
    const user_address = req.body.user_address || '';
    const user_birthday = req.body.user_birthday || '';
    const user_sign = req.body.user_sign || '';
    // 验证
    if(!id){
        res.json({success_code:0,messages:'修改用户信息失败！'})
        return;
    }
    // 更新数据
    let params = [user_name,user_sex,user_address,user_birthday,user_sign];
    let sql = "UPDATE pdd_user_info SET user_name = ?,user_sex = ?, user_address = ?, user_birthday = ?, user_sign = ? WHERE id = "+id;
    conn.query(sql,params,(error,result,fields)=>{
        if(error){
            res.json({success_code:0,messages:'修改失败！'});
            return;
        }
        res.json({success_code:200,messages:'修改用户信息成功！'})
    })
});

/*
*   添加商品到购物车(后台逻辑)
* */
router.post('/api/add_shop_cart',(req,res)=>{
    // 验证当前用户
    let user_id = req.body.id;
    if(!user_id || user_id !== req.session.userId){
        res.json({success_code:0,messages:'非法用户'});
        return;
    }
    // 获取客户端传来的商品信息，如果数据库中有则count+1,否则插入
    let goods_id = req.body.goods_id;
    let goods_name = req.body.goods_name;
    let thumb_url = req.body.thumb_url;
    let price = req.body.price;
    let buy_count = 1;
    let is_pay = 0;  // 0表示未购买  1表示购买   实际开发中应该用枚举类型
    // 查询语句
    let slq = "SELECT * FROM pdd_cart WHERE goods_id = " + goods_id;
    conn.query(slq,(error,result,field)=>{
        if(error){
            res.json({success_code:200,messages:'服务器错误'});
            return;
        }
        // 从数据库中获取到的为RowStackData类型的数据，转化为方便处理的对象类型
        result = JSON.parse(JSON.stringify(result));
        if(!result[0]){
            // 商品不存在，往数据库中添加一条数据
            let slq = "INSERT INTO pdd_cart(goods_id,goods_name,thumb_url,price,buy_count,is_pay) VALUES (?,?,?,?,?,?)";
            let params = [goods_id,goods_name,thumb_url,price,buy_count,is_pay];
            conn.query(slq,params,(error,result,field)=>{
                if(error){
                    res.json({success_code:0,messages:'商品添加失败'});
                    return;
                }
                res.json({success_code:200,messages:'商品添加成功'});
            })
        }else {
            // 修改该商品列将buy_count++
            let buy_count = result[0].buy_count + 1;
            let sql = "UPDATE pdd_cart SET buy_count =" + buy_count + " WHERE goods_id = "+ goods_id;
            conn.query(sql,(error,result,field)=> {
                if(error){
                    res.json({success_code:0,messages:'商品添加失败！'});
                    return;
                }
                res.json({success_code:200,messages:'加入购物车成功！'});
            })
        }
    })
});

/*
*   查询对应客户的购物车
* */
router.get('/api/get_cart',(req,res)=>{
    // 获取用户id
    if(!req.session.userId){
        res.json({success_code:0,messages:'请先登录！'});
        return;
    }
    // 查询数据库
    let sql = "SELECT * FROM pdd_cart";
    conn.query(sql,(error,result,field)=>{
        if(error){
            res.json({success_code:0,messages:'服务器错误'});
            return;
        }
        res.json({success_code:200,messages:result});
    })

})

module.exports = router;